home *** CD-ROM | disk | FTP | other *** search
=head1 NAME Glib::Object - Bindings for GObject =for position DESCRIPTION =head1 DESCRIPTION GObject is the base object class provided by the gobject library. It provides object properties with a notification system, and emittable signals. Glib::Object is the corresponding Perl object class. Glib::Objects are represented by blessed hash references, with a magical connection to the underlying C object. =cut =head1 HIERARCHY Glib::Object =for object Glib::Object Bindings for GObject =cut =head1 METHODS =head2 object = $class->B<new> (...) =over =over =item * ... (list) of key/value pairs, property values to set on creation =back Instantiate a Glib::Object of type I<$class>. Any key/value pairs in I<...> are used to set properties on the new object; see C<set>. This is designed to be inherited by Perl-derived subclasses (see L<Glib::Object::Subclass>), but you can actually use it to create any GObject-derived type. =back =head2 scalar = Glib::Object-E<gt>B<new_from_pointer> ($pointer, $noinc=FALSE) =over =over =item * $pointer (unsigned) a C pointer value as an integer. =item * $noinc (boolean) if true, do not increase the GObject's reference count when creating the Perl wrapper. this typically means that when the Perl wrapper will own the object. in general you don't want to do that, so the default is false. =back Create a Perl Glib::Object reference for the C object pointed to by I<$pointer>. You should need this I<very> rarely; it's intended to support foreign objects. NOTE: the cast from arbitrary integer to GObject may result in a core dump without warning, because the type-checking macro G_OBJECT() attempts to dereference the pointer to find a GTypeClass structure, and there is no portable way to validate the pointer. =back =head2 unsigned = $object-E<gt>B<get_data> ($key) =over =over =item * $key (string) =back Fetch the integer stored under the object data key I<$key>. These values do not have types; type conversions must be done manually. See C<set_data>. =back =head2 $object-E<gt>B<set_data> ($key, $data) =over =over =item * $key (string) =item * $data (scalar) =back GObject provides an arbitrary data mechanism that assigns unsigned integers to key names. Functionality overlaps with the hash used as the Perl object instance, so we strongly recommend you use hash keys for your data storage. The GObject data values cannot store type information, so they are not safe to use for anything but integer values, and you really should use this method only if you know what you are doing. =back =head2 pspec = $object_or_class_name->B<find_property> ($name) =over =over =item * $name (string) =back Find the definition of object property I<$name> for I<$object_or_class_name>; for the returned data see L<Glib::Object::list_properties>. =back =head2 $object-E<gt>B<freeze_notify> =over Stops emission of "notify" signals on I<$object>. The signals are queued until C<thaw_notify> is called on I<$object>. =back =head2 list = $object-E<gt>B<get> (...) =over =over =item * ... (list) list of property names =back Fetch and return the values for the object properties named in I<...>. =back =head2 $object->B<set> (key => $value, ...) =over =over =item * ... (list) =back Set object properties. =back =head2 list = $object_or_class_name->B<list_properties> =over =over =back List all the object properties for I<$object_or_class_name>; returns them as a list of hashes, containing these keys: =over =item name The name of the property =item type The type of the property =item owner_type The type that owns the property =item descr The description of the property =item flags The Glib::ParamFlags of the property =back =back =head2 $object-E<gt>B<notify> ($property_name) =over =over =item * $property_name (string) =back Emits a "notify" signal for the property I<$property> on I<$object>. =back =head2 gpointer = $object-E<gt>B<get_pointer> =over Complement of C<new_from_pointer>. =back =head2 list = $object-E<gt>B<get_property> (...) =over =over =back Alias for C<get>. =back =head2 $object->B<set_property> (key => $value, ...) =over =over =back Alias for C<set>. =back =head2 unsigned = $object_or_class_name-E<gt>B<signal_add_emission_hook> ($detailed_signal, $hook_func, $hook_data=undef) =over =over =item * $detailed_signal (string) of the form "signal-name::detail" =item * $hook_func (subroutine) =item * $hook_data (scalar) =back Add an emission hook for a signal. The hook will be called for any emission of that signal, independent of the instance. This is possible only for signals which don't have the C<G_SIGNAL_NO_HOOKS> flag set. The I<$hook_func> should be reference to a subroutine that looks something like this: sub emission_hook { my ($invocation_hint, $parameters, $hook_data) = @_; # $parameters is a reference to the @_ to be passed to # signal handlers, including the instance as $parameters->[0]. return $stay_connected; # boolean } This function returns an id that can be used with C<remove_emission_hook>. Since 1.100. =back =head2 list = $instance-E<gt>B<signal_chain_from_overridden> (...) =over =over =item * ... (list) =back Chain up to an overridden class closure; it is only valid to call this from a class closure override. Translation: because of various details in how GObjects are implemented, the way to override a virtual method on a GObject is to provide a new "class closure", or default handler for a signal. This happens when a class is registered with the type system (see Glib::Type::register and L<Glib::Object::Subclass>). When called from inside such an override, this method runs the overridden class closure. This is equivalent to calling $self->SUPER::$method (@_) in normal Perl objects. =back =head2 unsigned = $instance-E<gt>B<signal_connect> ($detailed_signal, $callback, $data=undef) =over =over =item * $detailed_signal (string) =item * $callback (subroutine) =item * $data (scalar) arbitrary data to be passed to each invocation of I<callback> =back Register I<callback> to be called on each emission of I<$detailed_signal>. Returns an identifier that may be used to remove this handler with C<< $object->signal_handler_disconnect >>. =back =head2 unsigned = $instance-E<gt>B<signal_connect_after> ($detailed_signal, $callback, $data=undef) =over =over =item * $detailed_signal (string) =item * $callback (scalar) =item * $data (scalar) =back Like C<signal_connect>, except that I<$callback> will be run after the default handler. =back =head2 unsigned = $instance-E<gt>B<signal_connect_swapped> ($detailed_signal, $callback, $data=undef) =over =over =item * $detailed_signal (string) =item * $callback (scalar) =item * $data (scalar) =back Like C<signal_connect>, except that I<$data> and I<$object> will be swapped on invocation of I<$callback>. =back =head2 retval = $object->B<signal_emit> ($name, ...) =over =over =item * $name (string) the name of the signal =item * ... (list) any arguments to pass to handlers. =back Emit the signal I<name> on I<$object>. The number and types of additional arguments in I<...> are determined by the signal; similarly, the presence and type of return value depends on the signal being emitted. =back =head2 $object-E<gt>B<signal_handler_block> ($handler_id) =over =over =item * $handler_id (unsigned) =back =back =head2 $object-E<gt>B<signal_handler_disconnect> ($handler_id) =over =over =item * $handler_id (unsigned) =back =back =head2 boolean = $object-E<gt>B<signal_handler_is_connected> ($handler_id) =over =over =item * $handler_id (unsigned) =back =back =head2 $object-E<gt>B<signal_handler_unblock> ($handler_id) =over =over =item * $handler_id (unsigned) =back =back =head2 integer = $instance-E<gt>B<signal_handlers_block_by_func> ($func, $data=undef) =over =over =item * $func (subroutine) function to block =item * $data (scalar) data to match, ignored if undef =back =back =head2 integer = $instance-E<gt>B<signal_handlers_disconnect_by_func> ($func, $data=undef) =over =over =item * $func (subroutine) function to block =item * $data (scalar) data to match, ignored if undef =back =back =head2 integer = $instance-E<gt>B<signal_handlers_unblock_by_func> ($func, $data=undef) =over =over =item * $func (subroutine) function to block =item * $data (scalar) data to match, ignored if undef =back =back =head2 scalar = $object_or_class_name-E<gt>B<signal_query> ($name) =over =over =item * $name (string) =back Look up information about the signal I<$name> on the instance type I<$object_or_class_name>, which may be either a Glib::Object or a package name. See also C<Glib::Type::list_signals>, which returns the same kind of hash refs as this does. Since 1.080. =back =head2 $object_or_class_name-E<gt>B<signal_remove_emission_hook> ($signal_name, $hook_id) =over =over =item * $signal_name (string) =item * $hook_id (unsigned) =back Remove a hook that was installed by C<add_emission_hook>. Since 1.100. =back =head2 $instance-E<gt>B<signal_stop_emission_by_name> ($detailed_signal) =over =over =item * $detailed_signal (string) =back =back =head2 $object-E<gt>B<thaw_notify> =over Reverts the effect of a previous call to C<freeze_notify>. This causes all queued "notify" signals on I<$object> to be emitted. =back =head2 boolean = Glib::Object-E<gt>B<set_threadsafe> ($threadsafe) =over =over =item * $threadsafe (boolean) =back Enables/disables threadsafe gobject tracking. Returns whether or not tracking will be successful and thus whether using perl ithreads will be possible. =back =head2 $object-E<gt>B<tie_properties> ($all=FALSE) =over =over =item * $all (boolean) if FALSE (or omitted) tie only properties for this object's class, if TRUE tie the properties of this and all parent classes. =back A special method avaiable to Glib::Object derivatives, it uses perl's tie facilities to associate hash keys with the properties of the object. For example: $button->tie_properties; # equivilent to $button->set (label => 'Hello World'); $button->{label} = 'Hello World'; print "the label is: ".$button->{label}."\n"; Attempts to write to read-only properties will croak, reading a write-only property will return '[write-only]'. Care must be taken when using tie_properties with objects of types created with Glib::Object::Subclass as there may be clashes with existing hash keys that could cause infinite loops. The solution is to use custom property get/set functions to alter the storage locations of the properties. =back =head1 SIGNALS =over =item B<notify> (Glib::Object, Glib::ParamSpec) =back =head1 ENUMS AND FLAGS =head2 flags Glib::SignalFlags =over =item * 'run-first' / 'G_SIGNAL_RUN_FIRST' =item * 'run-last' / 'G_SIGNAL_RUN_LAST' =item * 'run-cleanup' / 'G_SIGNAL_RUN_CLEANUP' =item * 'no-recurse' / 'G_SIGNAL_NO_RECURSE' =item * 'detailed' / 'G_SIGNAL_DETAILED' =item * 'action' / 'G_SIGNAL_ACTION' =item * 'no-hooks' / 'G_SIGNAL_NO_HOOKS' =back =head1 SEE ALSO L<Glib> =head1 COPYRIGHT Copyright (C) 2003-2006 by the gtk2-perl team. This software is licensed under the LGPL. See L<Glib> for a full notice. =cut 
